thread-pool-optimization/k6/io_user_test.js (1)

16-22: Great enhancement to error diagnostics!

The modification to the status check improves observability by adding detailed error logging while preserving the original functionality. When an HTTP request fails, you'll now see the status code, status text, and response headers, making debugging much easier.

A small suggestion for even better diagnostics would be to include the response body in the error log for cases where the API returns error details in the body.

 'status is 200': (r) => {
     const ok = r.status === 200;
     if (!ok) {
-        console.log(`❌ 실패 응답: ${r.status} ${r.status_text}, headers: ${JSON.stringify(r.headers)}`);
+        console.log(`❌ 실패 응답: ${r.status} ${r.status_text}, headers: ${JSON.stringify(r.headers)}, body: ${r.body}`);
     }
     return ok;
 },

javav-network/src/main/java/project/reflect/caculator/Calculator.java (1)

3-5: Add class-level Javadoc stub.

As an empty placeholder class, include a brief Javadoc describing its intended role or planned methods. This improves discoverability and sets clear expectations for future development. For example:

/**
 * Calculator provides core arithmetic operations for reflection-based utilities.
 * <p>
 * Future implementations may include methods like add, subtract, multiply, and divide.
 * </p>
 */
public class Calculator {
    // ...
}

javav-network/src/main/java/project/was/v3/PercentEncodingMain.java (2)

9-10: Consider renaming variables for clarity.
To improve readability, rename encode → encoded (or encodedString) and decode → decoded (or decodedString), since these store processed values.

Proposed diff:

-        String encode = URLEncoder.encode("가%", StandardCharsets.UTF_8);
+        String encoded = URLEncoder.encode("가%", StandardCharsets.UTF_8);

-        System.out.println("encode = " +  encode);
+        System.out.println("encoded = " + encoded);

-        String decode = URLDecoder.decode(encode, StandardCharsets.UTF_8);
+        String decoded = URLDecoder.decode(encoded, StandardCharsets.UTF_8);

-        System.out.println("decode = " + decode);
+        System.out.println("decoded = " + decoded);

Also applies to: 12-13

---

7-8: Add a brief class-level Javadoc.
Since this is a public utility/demo, a short Javadoc enhances discoverability in IDEs and generated docs.

Proposed addition:

+/**
+ * Demonstrates percent-encoding and decoding of a sample string using UTF-8.
+ */
 public class PercentEncodingMain {

thread-pool-optimization/src/main/java/project/threadpooloptimization/interfaces/UserController.java (1)

9-11: Remove or justify unused imports
The imports HandlerMethod, RequestMappingHandlerAdapter, and RequestMappingHandlerMapping are not used anywhere in this controller. Unused imports increase clutter and can confuse maintainers. If they’re planned for imminent use, please add a comment explaining their purpose; otherwise, remove them.

thread-pool-optimization/src/main/resources/application.yml (1)

4-6: Clarify the commented accept-count setting
Commenting out accept-count: 300 causes Tomcat to revert to its default backlog (usually 100). If you intend to support a backlog of 300 connections, uncomment or explicitly set this value. Otherwise, consider removing the commented line to avoid confusion.

javav-network/src/main/java/project/was/httpserver/ServletManager.java (2)

11-13: Consider adding validation in the add method.

The current implementation allows overwriting existing servlet mappings without any warning or validation. Consider adding validation to prevent accidentally overwriting existing mappings or to explicitly document this behavior.

public void add(String path, HttpServlet servlet){
+    if (servletMap.containsKey(path)) {
+        // Option 1: Throw exception
+        // throw new IllegalArgumentException("Servlet mapping already exists for path: " + path);
+        
+        // Option 2: Log warning
+        // System.out.println("Warning: Overwriting existing servlet mapping for path: " + path);
+    }
+    if (servlet == null) {
+        throw new IllegalArgumentException("Servlet cannot be null");
+    }
    servletMap.put(path, servlet);
}

---

1-22: Add JavaDoc comments for better documentation.

The class and its methods lack documentation. Adding JavaDoc comments would improve code maintainability and help other developers understand the purpose and usage of this class.

package project.was.httpserver;

import java.util.HashMap;
import java.util.Map;

+/**
+ * Manages servlet registrations and dispatches HTTP requests to the appropriate servlet.
+ * Serves as the central registry for mapping URL paths to servlet instances.
+ */
public class ServletManager {

    private final Map<String, HttpServlet> servletMap = new HashMap<>();

+    /**
+     * Registers a servlet for a specific URL path.
+     * 
+     * @param path The URL path to map the servlet to
+     * @param servlet The servlet instance to handle requests to the specified path
+     */
    public void add(String path, HttpServlet servlet){
        servletMap.put(path, servlet);
    }

+    /**
+     * Executes the appropriate servlet based on the incoming request.
+     * If no servlet is registered for the requested path, a 404 response is generated.
+     * 
+     * @param request The HTTP request to process
+     * @param response The HTTP response to populate
+     */
    public void execute(HttpRequest request, HttpResponse response){
        try{

        }catch (Exception e){

        }
    }
}

book/real-world-software-development/chapter4/document-management/gradle/wrapper/gradle-wrapper.properties (1)

1-6: Timestamp in the future detected

The timestamp in line 1 shows "Sat May 17 10:03:06 KST 2025" which appears to be in the future. While this doesn't affect functionality, it might indicate an incorrect system clock when this file was generated.

Otherwise, the Gradle wrapper configuration is standard and correctly configured with Gradle 8.5.

book/real-world-software-development/chapter4/document-management/src/main/java/project/Attributes.java (1)

4-14: Good use of constants class but add private constructor

Centralizing string constants is good practice to prevent duplication and typos. However, utility classes with only static members should typically have a private constructor to prevent instantiation.

Add a private constructor to prevent instantiation:

 public final class Attributes
 {
+    private Attributes() {
+        // Prevents instantiation
+    }
+
     public static final String PATH = "path";
     public static final String PATIENT = "patient";
     public static final String ADDRESS = "address";
     public static final String BODY = "body";
     public static final String WIDTH = "width";
     public static final String HEIGHT = "height";
     public static final String TYPE = "type";
     public static final String AMOUNT = "amount";
 }

book/real-world-software-development/chapter4/document-management/src/main/java/project/Document.java (2)

12-14: Add null check and consider additional methods

The getAttribute method should validate the input parameter. Also, consider adding methods to check if an attribute exists or to get all attributes.

Add null validation and consider additional helper methods:

     public String getAttribute(final String attributeName) {
+        if (attributeName == null) {
+            throw new IllegalArgumentException("Attribute name cannot be null");
+        }
         return attributes.get(attributeName);
     }
+
+    public boolean hasAttribute(final String attributeName) {
+        return attributeName != null && attributes.containsKey(attributeName);
+    }
+
+    public Map<String, String> getAttributes() {
+        return new HashMap<>(attributes);
+    }

---

8-8: Document constructor visibility intention

The constructor has package-private visibility. If this is intentional to restrict instantiation to within the package, consider adding a comment to make this clear.

-    Document(Map<String, String> attributes) {
+    // Package-private constructor to restrict instantiation to within this package
+    Document(Map<String, String> attributes) {

book/real-world-software-development/chapter4/document-management/src/main/java/project/ImageImporter.java (2)

21-21: Extract "IMAGE" as a constant

The string "IMAGE" is hardcoded in the importFile method. Consider extracting it to a constant for better maintainability.

 package project;

 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
 import java.util.HashMap;
 import java.util.Map;
 import static project.Attributes.*;

 public class ImageImporter implements Importer{
+    private static final String IMAGE_TYPE = "IMAGE";
 
     @Override
     public Document importFile(File file) throws IOException {
         final Map<String, String> attributes = new HashMap<>();
         attributes.put(PATH, file.getPath());

         final BufferedImage image = ImageIO.read(file);
         attributes.put(WIDTH, String.valueOf(image.getWidth()));
         attributes.put(HEIGHT, String.valueOf(image.getHeight()));
-        attributes.put(TYPE, "IMAGE");
+        attributes.put(TYPE, IMAGE_TYPE);
         return new Document(attributes);
     }

---

11-11: Add space after class name and interface name

There should be a space between the class name and the opening curly brace, as well as between implements and Importer.

-public class ImageImporter implements Importer{
+public class ImageImporter implements Importer {

book/real-world-software-development/chapter4/document-management/build/reports/tests/test/packages/chpater4.html (1)

134-135: Consider using HTTPS for external links.

The link to Gradle should use HTTPS instead of HTTP for improved security.

-<a href="http://www.gradle.org">Gradle 8.5</a>
+<a href="https://www.gradle.org">Gradle 8.5</a>

🧰 Tools

🪛 ast-grep (0.38.1)

[warning] 134-134: "This link points to a plaintext HTTP URL. Prefer an encrypted HTTPS URL if possible."
Context: Gradle 8.5
Note: [CWE-319] Authentication Bypass by Primary Weakness [REFERENCES]
- https://cwe.mitre.org/data/definitions/319.html

(plaintext-http-link-html)

book/real-world-software-development/chapter4/document-management/src/main/java/project/InvoiceImporter.java (2)

23-23: Consider using a constant for document type.

For consistency and to avoid magic strings, define a constant for the document type value.

+private static final String INVOICE_TYPE = "INVOICE";

@Override
public Document importFile(final File file) throws IOException {
    // ... existing code
    
    final Map<String, String> attributes = textFile.getAttributes();
-   attributes.put(TYPE, "INVOICE");
+   attributes.put(TYPE, INVOICE_TYPE);
    return new Document(attributes);
}

---

10-16: Add documentation about expected file format.

Adding a class-level Javadoc comment with information about the expected format of invoice files would improve maintainability.

+/**
+ * Imports invoice documents assuming the following format:
+ * - Contains a line starting with "Dear " followed by the patient name
+ * - Contains a line starting with "Amount: " followed by the invoice amount
+ */
class InvoiceImporter implements Importer {
    private static final String NAME_PREFIX = "Dear ";
    private static final String AMOUNT_PREFIX = "Amount: ";

book/real-world-software-development/chapter4/document-management/src/main/java/project/LetterImporter.java (2)

23-23: Consider using a constant for document type.

For consistency and to avoid magic strings, define a constant for the document type value.

+private static final String LETTER_TYPE = "LETTER";

@Override
public Document importFile(final File file) throws IOException {
    // ... existing code
    
    final Map<String, String> attributes = textFile.getAttributes();
-   attributes.put(TYPE, "LETTER");
+   attributes.put(TYPE, LETTER_TYPE);
    return new Document(attributes);
}

---

10-14: Add documentation about expected file format.

Adding a class-level Javadoc comment with information about the expected format of letter files would improve maintainability.

+/**
+ * Imports letter documents assuming the following format:
+ * - Contains a line starting with "Dear " followed by the patient name
+ * - Address starts at line 2 and continues until an empty line is found
+ * - Body starts after the address and continues until a line starting with "regards,"
+ */
class LetterImporter implements Importer {
    private static final String NAME_PREFIX = "Dear ";

book/real-world-software-development/chapter4/document-management/src/main/java/project/ReportImporter.java (3)

17-17: Improve readability of the line predicate.

Using line -> false as a predicate is a bit cryptic. Replace it with a more descriptive approach that clarifies the intent.

-textFile.addLines(2, line -> false, BODY);
+// Capture all remaining lines as the body (predicate never returns true)
+textFile.addLines(2, line -> false, BODY);

Alternatively, consider creating a named method:

+private boolean neverStop(String line) {
+    return false; // Continue processing until end of file
+}

@Override
public Document importFile(final File file) throws IOException {
    final TextFile textFile = new TextFile(file);
    textFile.addLineSuffix(NAME_PREFIX, PATIENT);
-   textFile.addLines(2, line -> false, BODY);
+   textFile.addLines(2, this::neverStop, BODY);

---

20-20: Consider using a constant for document type.

For consistency and to avoid magic strings, define a constant for the document type value.

+private static final String REPORT_TYPE = "REPORT";

@Override
public Document importFile(final File file) throws IOException {
    // ... existing code
    
    final Map<String, String> attributes = textFile.getAttributes();
-   attributes.put(TYPE, "REPORT");
+   attributes.put(TYPE, REPORT_TYPE);
    return new Document(attributes);
}

---

10-14: Add documentation about expected file format.

Adding a class-level Javadoc comment with information about the expected format of report files would improve maintainability.

+/**
+ * Imports report documents assuming the following format:
+ * - Contains a line starting with "Patient: " followed by the patient name
+ * - All content from line 2 onwards is captured as the body
+ */
class ReportImporter implements Importer {
    private static final String NAME_PREFIX = "Patient: ";

book/real-world-software-development/chapter4/document-management/src/main/java/project/Query.java (1)

22-31: Consider case-insensitive matching and trimming whitespace.

The current implementation uses exact string matching with contains(), which might not be user-friendly. Consider adding options for case-insensitive matching and trimming whitespace for more flexible searching.

@Override
public boolean test(final Document document) {
    return clauses.entrySet()
            .stream()
            .allMatch(entry -> {
                final String documentValue = document.getAttribute(entry.getKey());
                final String queryValue = entry.getValue();
-               return documentValue != null && documentValue.contains(queryValue);
+               return documentValue != null && 
+                      documentValue.toLowerCase().contains(queryValue.toLowerCase().trim());
            });
}

book/real-world-software-development/chapter4/document-management/src/main/java/project/TextFile.java (2)

30-48: Optimize memory usage in addLines method.

The method builds a potentially large string in memory using StringBuilder. For very large files, this could cause memory issues. Additionally, there's no validation for the starting index.

int addLines(
        final int start,
        final Predicate<String> isEnd,
        final String attributeName) {

+    // Validate input parameters
+    if (start < 0 || start >= lines.size()) {
+        throw new IllegalArgumentException("Invalid start index: " + start);
+    }
+    if (isEnd == null) {
+        throw new IllegalArgumentException("Predicate cannot be null");
+    }
+    if (attributeName == null || attributeName.isEmpty()) {
+        throw new IllegalArgumentException("Attribute name cannot be null or empty");
+    }

    final StringBuilder accumulator = new StringBuilder();
    int lineNumber;
    for (lineNumber = start; lineNumber < lines.size(); lineNumber++) {
        final String line = lines.get(lineNumber);
        if (isEnd.test(line)) {
            break;
        }

        accumulator.append(line);
        accumulator.append("\n");
    }
    attributes.put(attributeName, accumulator.toString().trim());
    return lineNumber;
}

---

50-57: Return result of addLineSuffix operation for better caller feedback.

The addLineSuffix method silently fails if it can't find a line starting with the prefix. Consider returning a boolean indicating success or failure, or throw an exception for critical scenarios.

-void addLineSuffix(final String prefix, final String attributeName) {
+boolean addLineSuffix(final String prefix, final String attributeName) {
+    if (prefix == null || attributeName == null) {
+        throw new IllegalArgumentException("Prefix and attribute name cannot be null");
+    }
+    
    for(final String line: lines) {
        if (line.startsWith(prefix)) {
            attributes.put(attributeName, line.substring(prefix.length()));
-            break;
+            return true;
        }
    }
+    return false;
}

book/real-world-software-development/chapter4/document-management/src/main/java/project/DocumentManagementSystem.java (3)

11-25: Good class structure with proper encapsulation

The class follows good object-oriented design principles with:

• Private mutable list with public immutable view (defensive programming)
• Strategy pattern for importers using a map of file extensions
• Clear separation of concerns via the Importer interface

Consider consolidating the instance initializer block with the constructor for better readability and maintainability.

 public DocumentManagementSystem() {
     extensionToImporter.put("letter", new LetterImporter());
     extensionToImporter.put("report", new ReportImporter());
     extensionToImporter.put("jpg", new ImageImporter());
+    extensionToImporter.put("invoice", new InvoiceImporter());
 }

-{
-    extensionToImporter.put("invoice", new InvoiceImporter());
-}

---

27-49: Simplify extension check logic and standardize error messages

The implementation correctly validates files and handles appropriate exceptions. However, there's some redundancy in the extension validation logic, and the error messages aren't consistent.

 public void importFile(final String path) throws IOException {
     final File file = new File(path);
     if (!file.exists()) {
         throw new FileNotFoundException(path);
     }

     final int separatorIndex = path.lastIndexOf('.');
-    if (separatorIndex != -1) {
-        if (separatorIndex == path.length()) {
-            throw new UnknownFileTypeException("No extension found For file: " + path);
-        }
+    if (separatorIndex != -1 && separatorIndex < path.length() - 1) {
         final String extension = path.substring(separatorIndex + 1);
         final Importer importer = extensionToImporter.get(extension);
         if (importer == null) {
-            throw new UnknownFileTypeException("For file: " + path);
+            throw new UnknownFileTypeException("Unknown extension for file: " + path);
         }

         final Document document = importer.importFile(file);
         documents.add(document);
     } else {
         throw new UnknownFileTypeException("No extension found For file: " + path);
     }
 }

---

51-59: Consider adding Javadoc for public methods

The search method leverages Java 8 streams and the Query class effectively. Add documentation to improve code readability and maintainability.

+/**
+ * Returns an unmodifiable view of all documents in the system.
+ * 
+ * @return List of documents
+ */
 public List<Document> contents() {
     return documentsView;
 }

+/**
+ * Searches for documents matching the specified query string.
+ * The query format is "key:value,key:value" where keys are document attributes.
+ * 
+ * @param query the query string to search for
+ * @return List of matching documents
+ */
 public List<Document> search(final String query) {
     return documents.stream()
             .filter(Query.parse(query))
             .collect(Collectors.toList());
 }

book/real-world-software-development/chapter4/document-management/build/reports/tests/test/classes/chpater4.DocumentManagementSystemTest.html (1)

479-480: Use HTTPS links for security

Update the Gradle link to use HTTPS instead of HTTP for better security.

-<a href="http://www.gradle.org">Gradle 8.5</a>
+<a href="https://www.gradle.org">Gradle 8.5</a>

🧰 Tools

🪛 ast-grep (0.38.1)

[warning] 479-479: "This link points to a plaintext HTTP URL. Prefer an encrypted HTTPS URL if possible."
Context: Gradle 8.5
Note: [CWE-319] Authentication Bypass by Primary Weakness [REFERENCES]
- https://cwe.mitre.org/data/definitions/319.html

(plaintext-http-link-html)

book/real-world-software-development/chapter4/document-management/build/reports/tests/test/js/report.js (2)

1-3: Remove redundant 'use strict' directive

JavaScript modules automatically run in strict mode without needing the directive.

 (function (window, document) {
-    "use strict";
 
     var tabs = {};

🧰 Tools

🪛 Biome (1.9.4)

[error] 2-2: Redundant use strict directive.

The entire contents of JavaScript modules are automatically in strict mode, with no statement needed to initiate it.
Safe fix: Remove the redundant use strict directive.

(lint/suspicious/noRedundantUseStrict)

---

14-28: Consider using modern DOM manipulation methods

The code works but uses older DOM manipulation approaches. Consider using modern methods like classList instead of directly manipulating class attributes.

 function getClassAttribute(element) {
-    if (element.getAttribute("className")) {
-        return element.getAttribute("className");
-    } else {
-        return element.getAttribute("class");
-    }
+    return element.className;
 }

 function addClass(element, classValue) {
-    changeElementClass(element, getClassAttribute(element) + " " + classValue);
+    element.classList.add(classValue);
 }

 function removeClass(element, classValue) {
-    changeElementClass(element, getClassAttribute(element).replace(classValue, ""));
+    element.classList.remove(classValue);
 }

book/real-world-software-development/chapter4/document-management/src/test/java/chpater4/DocumentManagementSystemTest.java (1)

1-1: Fix package name typo.

The package name chpater4 contains a typo and should be chapter4 instead.

-package chpater4;
+package chapter4;

book/real-world-software-development/chapter4/document-management/build/reports/tests/test/css/base-style.css (2)

104-105: Remove empty CSS rule.

The CSS rule for div.tab is empty and doesn't serve any purpose. Consider removing it or adding the necessary styles.

-div.tab {
-}

🧰 Tools

🪛 Biome (1.9.4)

[error] 104-105: An empty block isn't allowed.

Consider removing the empty block or adding styles inside it.

(lint/suspicious/noEmptyBlock)

---

1-179: Consider excluding auto-generated CSS files from version control.

This appears to be an auto-generated CSS file from test reports. Consider whether it's necessary to include this in version control, as these files are typically regenerated when tests are run. You might want to add build output directories to your .gitignore file.

Would you like me to propose a suitable .gitignore configuration for excluding build outputs?

🧰 Tools

🪛 Biome (1.9.4)

[error] 104-105: An empty block isn't allowed.

Consider removing the empty block or adding styles inside it.

(lint/suspicious/noEmptyBlock)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
Cache: Disabled due to data retention organization setting
Knowledge Base: Disabled due to data retention organization setting